const list = [
    {
        id: 'default',
        url: process.env.NEXT_PUBLIC_API_URL_ALIAS,
        label: "静默",
        type: 'STOP',
        duration: 20,
        seep: [[1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6, 6], [7, 7], [8, 8], [9, 9], [10, 10], [11, 11], [12, 12], [13, 13], [14, 14], [15, 15], [16, 16], [17, 17], [18, 18], [19, 19], [20, 20]],
        seepReverse: [[1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6, 6], [7, 7], [8, 8], [9, 9], [10, 10], [11, 11], [12, 12], [13, 13], [14, 14], [15, 15], [16, 16], [17, 17], [18, 18], [19, 19], [20, 20]]
    },
    {
        id: 'start_one',
        url: process.env.NEXT_PUBLIC_API_URL_ALIAS2,
        label: "视频1",
        type: 'START',
        duration: 20,
        seep: [[1, 4], [6, 8], [9, 12], [14, 18]],
        seepReverse: [[3, 7], [9, 12], [13, 15], [17, 20]] // 倒放对应区间
    },
    {
        id: 'start_two',
        url: process.env.NEXT_PUBLIC_API_URL_ALIAS2,
        label: "视频1",
        type: 'START',
        duration: 20,
        seep: [[1, 3], [4, 7], [8, 12], [13, 16], [17, 19]],
        seepReverse: [[2, 4], [5, 8], [9, 13], [14, 17], [18, 20]] // 倒放对应区间
    },
    {
        id: 'start_three',
        url: process.env.NEXT_PUBLIC_API_URL_ALIAS2,
        label: "视频1",
        type: 'START',
        duration: 20,
        seep: [[3, 6], [7, 9], [12, 15], [16, 20]],
        seepReverse: [[1, 5], [6, 9], [12, 14], [15, 18]] // 倒放对应区间
    },
    {
        id: 'start_four',
        url: process.env.NEXT_PUBLIC_API_URL_ALIAS2,
        label: "视频1",
        type: 'START',
        duration: 20,
        seep: [[1, 4], [5, 8], [9, 13], [15, 18]],
        seepReverse: [[3, 6], [8, 12], [14, 16], [17, 20]] // 倒放对应区间
    },
    {
        id: 'start_five',
        url: process.env.NEXT_PUBLIC_API_URL_ALIAS2,
        label: "视频1",
        type: 'START',
        duration: 20,
        seep: [[1, 3], [5, 9], [10, 12], [13, 17]],
        seepReverse: [[4, 8], [9, 11], [12, 16], [18, 20]] // 倒放对应区间
    },
    {
        id: 'start_six',
        url: process.env.NEXT_PUBLIC_API_URL_ALIAS2,
        label: "视频1",
        type: 'START',
        duration: 20,
        seep: [[4, 7], [9, 12], [14, 16], [17, 20]],
        seepReverse: [[1, 4], [5, 7], [9, 12], [14, 17]] // 倒放对应区间
    },
]
const list2 = [
    [[1, 4], [6, 8], [9, 12], [14, 18]],
    [[1, 3], [4, 7], [8, 12], [13, 16], [17, 19]],
    [[3, 6], [7, 9], [12, 15], [16, 20]],
    [[1, 4], [5, 8], [9, 13], [15, 18]],
    [[1, 3], [5, 9], [10, 12], [13, 17]],
    [[4, 7], [9, 12], [14, 16], [17, 20]]
]

/**
 * 视频总时长是20s
 * seep 数字中存放的是说话的时间点
 * 例如：[[1, 3], [5, 7], [8, 11], [13, 16], [17, 19]]
 * 表示在1-3秒之间说话，在5-7秒之间说话，在8-11秒之间说话，在13-16秒之间说话，在17-19秒之间说话
 * 我现在有一个不动的视频假如说她现在播放到了237s那他取余20s=17s
 * 然后我根据17s去seep中找那个元素是从17开始进行播放的必须是开始时间
 * 如果是15那么就去找离15最近的开始时间 
 * 让后返回还差几秒到下一个开始时间
 * 
 * 1.seep里面存放的是当前视频正处于说话的区间
 * 2.当视频开始播放的时候想去动态的切换他的视频 但是怕出现跳帧的情况所以我把视频说话的区间都记录的了下来剩下的都是处于静止的状态方便我去切换视频的时候不会出现跳帧的情况
 * 3.视频切换的时候 假如视频处于播放状态那就需要等视频播放完了以后去寻找在视频静默的时候有那个视频也是静默状态并且离开始说话的时间段很近就去切换
 * 4.返回值 要返回的是下一个视频的信息以及从开始切换到切换完毕后一共要等待的时长 比如说我现在的视频是15秒处于13,16的中间下一个要切换的视频是17,19那我返回的延迟应该是16-15+17-16=2
 */

// 更简洁且 nextStart 不会为 undefined 的主函数
function getNextSwitchInfo(currentTime, typeFilter, currentId) {
    const currentItem = list.find(item => item.id === currentId);
    if (!currentItem) return null;

    const videoDuration = currentItem.duration || 20;
    const fullCycleDuration = videoDuration * 2; // 正放+倒放的完整周期
    const timeInFullCycle = currentTime % fullCycleDuration;

    // 判断当前是否处于倒放阶段
    const isReverse = timeInFullCycle >= videoDuration;
    const timeInCycle = isReverse ?
        (fullCycleDuration - timeInFullCycle) : // 倒放时，时间轴反向计算
        timeInFullCycle; // 正放时，直接使用

    const seepData = isReverse ? currentItem.seepReverse : currentItem.seep;

    // 1. 判断是否在说话区间
    let currentEnd = null;
    for (const [start, end] of seepData) {
        if (timeInCycle >= start && timeInCycle <= end) {
            currentEnd = end;
            break;
        }
    }

    // 2. 计算说完本视频后要切换的时间点
    let switchTime = currentTime;
    let waitToEnd = 0;
    if (currentEnd !== null) {
        waitToEnd = currentEnd - timeInCycle;
        switchTime += waitToEnd;
    }

    // 3. 查找下一个视频的下一个说话区间
    let minWait = Infinity;
    let nextItem = null;
    let nextStart = null;
    for (const item of list) {
        if (typeFilter && item.type !== typeFilter) continue;
        const duration = item.duration || 20;
        const itemFullCycleDuration = duration * 2;
        const itemTimeInFullCycle = switchTime % itemFullCycleDuration;

        // 判断目标视频在切换时间点是否处于倒放状态
        const itemIsReverse = itemTimeInFullCycle >= duration;
        const tInCycle = itemIsReverse ?
            (itemFullCycleDuration - itemTimeInFullCycle) :
            itemTimeInFullCycle;

        const itemSeepData = itemIsReverse ? item.seepReverse : item.seep;
        let found = false;
        for (const [start, end] of itemSeepData) {
            if (start >= tInCycle) {
                const wait = start - tInCycle;
                if (wait < minWait) {
                    minWait = wait;
                    nextItem = item;
                    nextStart = start;
                }
                found = true;
                break;
            }
        }
        // 如果本周期没有，取下一个周期的第一个说话区间
        if (!found) {
            // 如果当前周期没有合适的说话区间，考虑下一个周期
            // 计算到下一个周期开始需要等待的时间
            const waitToCycle = duration - tInCycle;

            // 计算下一个周期开始时的绝对时间点
            const nextCycleAbsoluteTime = switchTime + waitToCycle;
            const nextCycleTimeInFullCycle = nextCycleAbsoluteTime % (duration * 2);
            const nextCycleIsReverse = nextCycleTimeInFullCycle >= duration;
            const nextCycleSeepData = nextCycleIsReverse ? item.seepReverse : item.seep;

            if (nextCycleSeepData.length > 0) {
                // 总等待时间 = 等待周期结束 + 下一个周期第一个说话区间的起点
                const waitInCycle = nextCycleSeepData[0][0];
                const totalWait = waitToCycle + waitInCycle;

                if (totalWait < minWait) {
                    minWait = totalWait;
                    nextItem = item;
                    nextStart = nextCycleSeepData[0][0];
                }
            }
        }
    }
    // 总延迟 = 说完本视频剩余 + 下一个视频等待说话区间
    const totalDelay = waitToEnd + minWait;
    return { item: nextItem, diff: totalDelay, nextStart };
}

// 示例用法 - 自动判断正放/倒放
const currentId = 'default';
console.log('=== 自动判断正放/倒放模式测试 ===');

// 示例1：15s - 正放阶段 (0-20s是正放)
const result1 = getNextSwitchInfo(428, 'START', currentId);
console.log(`示例1：当前时间: 428 (正放阶段)`);
console.log('下一个视频:', result1.item, '总延迟:', result1.diff, '秒，下一个说话区间起点:', result1.nextStart);
console.log('------------------------');

// 示例2：35s - 倒放阶段 (20-40s是倒放，相当于倒放的第5秒)
const result2 = getNextSwitchInfo(35, 'START', currentId);
console.log(`示例2：当前时间: 35s (倒放阶段，相当于倒放第${40 - 35}秒)`);
console.log('下一个视频:', result2.item, '总延迟:', result2.diff, '秒，下一个说话区间起点:', result2.nextStart);
console.log('------------------------');

// 示例3：55s - 正放阶段 (40-60s又是正放，相当于正放第15秒)
const result3 = getNextSwitchInfo(55, 'START', currentId);
console.log(`示例3：当前时间: 55s (正放阶段，相当于正放第${55 - 40}秒)`);
console.log('下一个视频:', result3.item, '总延迟:', result3.diff, '秒，下一个说话区间起点:', result3.nextStart);
console.log('------------------------');

console.log('')



// 双-偏右    右    双    腹部